Add Stream wrappers for memory and text-based types by ViveliDuCh · Pull Request #126669 · dotnet/runtime

ViveliDuCh · 2026-04-08T22:31:52Z

Introduces standardized stream wrappers for text and memory types as public sealed classes (StringStream, ReadOnlyMemoryStream, WritableMemoryStream, and ReadOnlySequenceStream ) as approved in API review (video).

What's included

StringStream (System.IO, CoreLib): non-seekable, read-only stream that encodes string or ReadOnlyMemory<char> on-the-fly. Encoding is required (no default). Never emits BOMs.
ReadOnlyMemoryStream (System.IO, CoreLib): seekable, read-only stream over ReadOnlyMemory<byte>
WritableMemoryStream (System.IO, CoreLib): seekable, read-write stream over Memory<byte> with fixed capacity
ReadOnlySequenceStream (System.Buffers, System.Memory): seekable, read-only stream over ReadOnlySequence<byte>
Ref assembly updates for System.Runtime and System.Memory
Updated 3 internal call sites (ReadOnlyMemoryContent, XmlPreloadedResolver, JsonXmlDataContract) to use the new types
Conformance and behavioral tests for all 4 types

Implementation notes

All types are public sealed with direct constructors: the review moved away from factory methods on Stream to avoid derived-type IntelliSense noise
StringStream encodes directly into the caller's buffer in Read() rather than using an internal byte buffer
ReadOnlyMemoryStream and WritableMemoryStream derive from MemoryStream.
TryGetBuffer returns false and GetBuffer throws on the memory stream types (no publiclyVisible support for now)

Limitations

The internal shared-source ReadOnlyMemoryStream in Common/ cannot be fully replaced:
- System.Memory.Data multi-targets netstandard2.0 where the new public type doesn't exist.
- System.Net.Http (net11.0 only) can adopt it directly.

Follow-up work

IBufferWriter<byte> → Stream wrapper (separate proposal per #100434)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot

Pull request overview

This PR introduces new standardized Stream wrapper types across CoreLib and System.Memory, aligning with the approved API shape from #82801 and updating a few internal call sites to use the new wrappers.

Changes:

Added new public sealed stream wrappers: StringStream, ReadOnlyMemoryStream, WritableMemoryStream (CoreLib) and ReadOnlySequenceStream (System.Memory).
Updated reference assemblies and project files to expose/compile the new APIs.
Added conformance + targeted behavioral tests, and updated select internal consumers to use StringStream.

Reviewed changes

Copilot reviewed 23 out of 23 changed files in this pull request and generated 9 comments.

Show a summary per file

File	Description
src/libraries/System.Private.CoreLib/src/System/IO/StringStream.cs	Implements the new `StringStream` API (read-only, non-seekable, on-the-fly encoding).
src/libraries/System.Private.CoreLib/src/System/IO/ReadOnlyMemoryStream.cs	Implements seekable read-only stream over `ReadOnlyMemory<byte>`.
src/libraries/System.Private.CoreLib/src/System/IO/WritableMemoryStream.cs	Implements seekable fixed-capacity read/write stream over `Memory<byte>`.
src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems	Wires new CoreLib stream wrapper source files into the build.
src/libraries/System.Private.CoreLib/src/Resources/Strings.resx	Adds a new resource string entry (currently appears unused).
src/libraries/System.Runtime/ref/System.Runtime.cs	Updates public API surface to include the new stream wrapper types (and a small ref signature normalization change).
src/libraries/System.Runtime/tests/System.IO.Tests/System.IO.Tests.csproj	Includes the new test files in the System.IO test project.
src/libraries/System.Runtime/tests/System.IO.Tests/StringStream/StringStreamConformanceTests.cs	Adds conformance coverage for `StringStream` (string + `ReadOnlyMemory<char>` overloads).
src/libraries/System.Runtime/tests/System.IO.Tests/StringStream/StringStreamTests_String.cs	Adds targeted `StringStream(string, Encoding)` behavioral tests.
src/libraries/System.Runtime/tests/System.IO.Tests/StringStream/StringStreamTests_Memory.cs	Adds targeted `StringStream(ReadOnlyMemory<char>, Encoding)` behavioral tests.
src/libraries/System.Runtime/tests/System.IO.Tests/ReadOnlyMemoryStream/ReadOnlyMemoryStreamConformanceTests.cs	Adds conformance coverage for `ReadOnlyMemoryStream`.
src/libraries/System.Runtime/tests/System.IO.Tests/ReadOnlyMemoryStream/ReadOnlyMemoryStreamTests.cs	Adds targeted `ReadOnlyMemoryStream` behavioral tests.
src/libraries/System.Runtime/tests/System.IO.Tests/WritableMemoryStream/WritableMemoryStreamConformanceTests.cs	Adds conformance coverage for `WritableMemoryStream` (with some overridden tests).
src/libraries/System.Runtime/tests/System.IO.Tests/WritableMemoryStream/WritableMemoryStreamTests.cs	Adds targeted `WritableMemoryStream` behavioral tests.
src/libraries/System.Memory/src/System/Buffers/ReadOnlySequenceStream.cs	Implements `ReadOnlySequenceStream` over `ReadOnlySequence<byte>`.
src/libraries/System.Memory/src/System.Memory.csproj	Includes the new `ReadOnlySequenceStream` source file in System.Memory.
src/libraries/System.Memory/src/Resources/Strings.resx	Adds SR strings needed for stream-like exception messages in System.Memory.
src/libraries/System.Memory/ref/System.Memory.cs	Adds `ReadOnlySequenceStream` to the System.Memory ref surface.
src/libraries/System.Memory/tests/System.Memory.Tests.csproj	Adds tests for `ReadOnlySequenceStream` and references StreamConformanceTests.
src/libraries/System.Memory/tests/ReadOnlyBuffer/ReadOnlySequenceStreamTests.cs	Adds targeted behavioral tests for multi-segment `ReadOnlySequenceStream` scenarios.
src/libraries/System.Memory/tests/ReadOnlyBuffer/ReadOnlySequenceStream.ConformanceTests.cs	Adds conformance coverage for `ReadOnlySequenceStream`.
src/libraries/System.Private.Xml/src/System/Xml/Resolvers/XmlPreloadedResolver.cs	Switches internal string-to-stream conversion to `StringStream`.
src/libraries/System.Private.DataContractSerialization/src/System/Runtime/Serialization/Json/JsonXmlDataContract.cs	Switches internal string-to-stream conversion to `StringStream`.

Comments suppressed due to low confidence (1)

src/libraries/System.Private.DataContractSerialization/src/System/Runtime/Serialization/Json/JsonXmlDataContract.cs:38

Variable is still named 'memoryStream' but the implementation is now StringStream (not a MemoryStream). Rename the local to avoid implying the stream is seekable/in-memory-buffered (e.g., 'xmlContentStream').

            Stream memoryStream = new StringStream(xmlContent, Encoding.UTF8);
            object? xmlValue;
            XmlDictionaryReaderQuotas? quotas = ((JsonReaderDelegator)jsonReader).ReaderQuotas;
            if (quotas == null)
            {
                xmlValue = dataContractSerializer.ReadObject(memoryStream);

Copilot

Pull request overview

Copilot reviewed 23 out of 23 changed files in this pull request and generated 10 comments.

…onvert edge case. Flush strategy update.

Copilot

Pull request overview

Copilot reviewed 23 out of 23 changed files in this pull request and generated 3 comments.

Copilot

Pull request overview

Copilot reviewed 23 out of 23 changed files in this pull request and generated 3 comments.

adamsitnik

I really like the simplicity of the design and implementation.

Overall it LGTM, I found mostly some nits related to tests. I will need to perform another round for StringStream.

Thank you @ViveliDuCh !

ViveliDuCh · 2026-06-01T22:25:40Z

Note

AI-generated content (Copilot)

Base Class Benchmark: `MemoryStream` vs `Stream`

Investigation: Comparing sealed subclass performance when deriving from MemoryStream (current API review decision) vs Stream directly.

Both variants have identical method bodies — the only difference is the base class. Categories measured:

Construction — object size difference (~81 vs ~37 bytes), base constructor field init
ReadByte — per-byte hot loop (concrete & polymorphic dispatch)
ReadSpan — 4096-byte chunked reads
CopyTo — optimized single-span write
WriteByte / WriteSpan — write hot paths
BinaryReader — integration through BinaryReader wrapper

Per the investigation doc and benchmark spec, the prediction is that only construction will show a measurable difference; all operations should be within noise (±2-3%) since both are sealed with identical devirtualization behavior.

@EgorBot -linux_amd -osx_arm64

using System;
using System.IO;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Configs;
using BenchmarkDotNet.Running;

BenchmarkSwitcher.FromAssembly(typeof(ReadOnlyStreamBenchmarks).Assembly).Run(args);

// ═══════════════════════════════════════════════════════════════════════════════
// Benchmark: ReadOnlyMemoryStream — MemoryStream base vs Stream base
// ═══════════════════════════════════════════════════════════════════════════════

[MemoryDiagnoser]
[GroupBenchmarksBy(BenchmarkLogicalGroupRule.ByCategory)]
[CategoriesColumn]
public class ReadOnlyStreamBenchmarks
{
    private byte[] _data = default!;
    private ReadOnlyMemory<byte> _memory;

    [Params(1024, 65536)]
    public int Size { get; set; }

    [GlobalSetup]
    public void Setup()
    {
        _data = new byte[Size];
        new Random(42).NextBytes(_data);
        _memory = _data.AsMemory();
    }

    // ── Construction ──

    [BenchmarkCategory("Construction"), Benchmark(Baseline = true)]
    public object Construct_MemoryStreamBase() => new ReadOnlyMemoryStreamMS(_memory);

    [BenchmarkCategory("Construction"), Benchmark]
    public object Construct_StreamBase() => new ReadOnlyMemoryStreamS(_memory);

    [BenchmarkCategory("Construction"), Benchmark]
    public object Construct_ByteArrayBaseline() => new MemoryStream(_data, writable: false);

    // ── ReadByte (concrete type — devirtualized) ──

    [BenchmarkCategory("ReadByte"), Benchmark(Baseline = true)]
    public int ReadByte_MemoryStreamBase()
    {
        var s = new ReadOnlyMemoryStreamMS(_memory);
        int count = 0;
        while (s.ReadByte() != -1) count++;
        return count;
    }

    [BenchmarkCategory("ReadByte"), Benchmark]
    public int ReadByte_StreamBase()
    {
        var s = new ReadOnlyMemoryStreamS(_memory);
        int count = 0;
        while (s.ReadByte() != -1) count++;
        return count;
    }

    [BenchmarkCategory("ReadByte"), Benchmark]
    public int ReadByte_ByteArrayBaseline()
    {
        var s = new MemoryStream(_data, writable: false);
        int count = 0;
        while (s.ReadByte() != -1) count++;
        return count;
    }

    // ── ReadByte via Stream reference (polymorphic dispatch) ──

    [BenchmarkCategory("ReadByte_Polymorphic"), Benchmark(Baseline = true)]
    public int ReadBytePoly_MemoryStreamBase()
    {
        Stream s = new ReadOnlyMemoryStreamMS(_memory);
        int count = 0;
        while (s.ReadByte() != -1) count++;
        return count;
    }

    [BenchmarkCategory("ReadByte_Polymorphic"), Benchmark]
    public int ReadBytePoly_StreamBase()
    {
        Stream s = new ReadOnlyMemoryStreamS(_memory);
        int count = 0;
        while (s.ReadByte() != -1) count++;
        return count;
    }

    // ── ReadSpan (chunked) ──

    [BenchmarkCategory("ReadSpan"), Benchmark(Baseline = true)]
    public int ReadSpan_MemoryStreamBase()
    {
        var s = new ReadOnlyMemoryStreamMS(_memory);
        Span<byte> buf = stackalloc byte[4096];
        int total = 0, n;
        while ((n = s.Read(buf)) > 0) total += n;
        return total;
    }

    [BenchmarkCategory("ReadSpan"), Benchmark]
    public int ReadSpan_StreamBase()
    {
        var s = new ReadOnlyMemoryStreamS(_memory);
        Span<byte> buf = stackalloc byte[4096];
        int total = 0, n;
        while ((n = s.Read(buf)) > 0) total += n;
        return total;
    }

    [BenchmarkCategory("ReadSpan"), Benchmark]
    public int ReadSpan_ByteArrayBaseline()
    {
        var s = new MemoryStream(_data, writable: false);
        Span<byte> buf = stackalloc byte[4096];
        int total = 0, n;
        while ((n = s.Read(buf)) > 0) total += n;
        return total;
    }

    // ── CopyTo ──

    [BenchmarkCategory("CopyTo"), Benchmark(Baseline = true)]
    public void CopyTo_MemoryStreamBase()
    {
        var s = new ReadOnlyMemoryStreamMS(_memory);
        s.CopyTo(Stream.Null);
    }

    [BenchmarkCategory("CopyTo"), Benchmark]
    public void CopyTo_StreamBase()
    {
        var s = new ReadOnlyMemoryStreamS(_memory);
        s.CopyTo(Stream.Null);
    }

    [BenchmarkCategory("CopyTo"), Benchmark]
    public void CopyTo_ByteArrayBaseline()
    {
        var s = new MemoryStream(_data, writable: false);
        s.CopyTo(Stream.Null);
    }

    // ── BinaryReader integration ──

    [BenchmarkCategory("BinaryReader"), Benchmark(Baseline = true)]
    public int BinaryReader_MemoryStreamBase()
    {
        var s = new ReadOnlyMemoryStreamMS(_memory);
        using var br = new BinaryReader(s);
        int count = 0;
        for (int i = 0; i < Size; i++) { br.ReadByte(); count++; }
        return count;
    }

    [BenchmarkCategory("BinaryReader"), Benchmark]
    public int BinaryReader_StreamBase()
    {
        var s = new ReadOnlyMemoryStreamS(_memory);
        using var br = new BinaryReader(s);
        int count = 0;
        for (int i = 0; i < Size; i++) { br.ReadByte(); count++; }
        return count;
    }

    [BenchmarkCategory("BinaryReader"), Benchmark]
    public int BinaryReader_ByteArrayBaseline()
    {
        var s = new MemoryStream(_data, writable: false);
        using var br = new BinaryReader(s);
        int count = 0;
        for (int i = 0; i < Size; i++) { br.ReadByte(); count++; }
        return count;
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// Benchmark: WritableMemoryStream — MemoryStream base vs Stream base
// ═══════════════════════════════════════════════════════════════════════════════

[MemoryDiagnoser]
[GroupBenchmarksBy(BenchmarkLogicalGroupRule.ByCategory)]
[CategoriesColumn]
public class WritableStreamBenchmarks
{
    private byte[] _data = default!;

    [Params(1024, 65536)]
    public int Size { get; set; }

    [GlobalSetup]
    public void Setup()
    {
        _data = new byte[Size];
        new Random(42).NextBytes(_data);
    }

    // ── Construction ──

    [BenchmarkCategory("Construction"), Benchmark(Baseline = true)]
    public object Construct_MemoryStreamBase() => new WritableMemoryStreamMS(new byte[Size]);

    [BenchmarkCategory("Construction"), Benchmark]
    public object Construct_StreamBase() => new WritableMemoryStreamS(new byte[Size]);

    // ── WriteByte ──

    [BenchmarkCategory("WriteByte"), Benchmark(Baseline = true)]
    public void WriteByte_MemoryStreamBase()
    {
        var s = new WritableMemoryStreamMS(new byte[Size]);
        for (int i = 0; i < Size; i++) s.WriteByte((byte)i);
    }

    [BenchmarkCategory("WriteByte"), Benchmark]
    public void WriteByte_StreamBase()
    {
        var s = new WritableMemoryStreamS(new byte[Size]);
        for (int i = 0; i < Size; i++) s.WriteByte((byte)i);
    }

    [BenchmarkCategory("WriteByte"), Benchmark]
    public void WriteByte_ByteArrayBaseline()
    {
        var s = new MemoryStream(new byte[Size], writable: true);
        for (int i = 0; i < Size; i++) s.WriteByte((byte)i);
    }

    // ── WriteSpan ──

    [BenchmarkCategory("WriteSpan"), Benchmark(Baseline = true)]
    public void WriteSpan_MemoryStreamBase()
    {
        var s = new WritableMemoryStreamMS(new byte[Size]);
        ReadOnlySpan<byte> chunk = _data.AsSpan(0, Math.Min(256, Size));
        for (int i = 0; i < Size / Math.Max(chunk.Length, 1); i++) s.Write(chunk);
    }

    [BenchmarkCategory("WriteSpan"), Benchmark]
    public void WriteSpan_StreamBase()
    {
        var s = new WritableMemoryStreamS(new byte[Size]);
        ReadOnlySpan<byte> chunk = _data.AsSpan(0, Math.Min(256, Size));
        for (int i = 0; i < Size / Math.Max(chunk.Length, 1); i++) s.Write(chunk);
    }

    [BenchmarkCategory("WriteSpan"), Benchmark]
    public void WriteSpan_ByteArrayBaseline()
    {
        var s = new MemoryStream(new byte[Size], writable: true);
        ReadOnlySpan<byte> chunk = _data.AsSpan(0, Math.Min(256, Size));
        for (int i = 0; i < Size / Math.Max(chunk.Length, 1); i++) s.Write(chunk);
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// Variant A: ReadOnlyMemoryStream : MemoryStream (current API review decision)
// Source: PR #126669 — sealed subclass, all virtuals overridden, independent state
// ═══════════════════════════════════════════════════════════════════════════════

public class ReadOnlyMemoryStreamMS : MemoryStream
{
    private ReadOnlyMemory<byte> _buffer;
    private int _position;
    private bool _isOpen;

    public ReadOnlyMemoryStreamMS(ReadOnlyMemory<byte> source) : base()
    {
        _buffer = source;
        _isOpen = true;
    }

    public override bool CanRead => _isOpen;
    public override bool CanSeek => _isOpen;
    public override bool CanWrite => false;
    public override int Capacity { get => _buffer.Length; set => throw new NotSupportedException(); }
    public override long Length { get { ThrowClosed(); return _buffer.Length; } }

    public override long Position
    {
        get { ThrowClosed(); return _position; }
        set
        {
            ThrowClosed();
            ArgumentOutOfRangeException.ThrowIfNegative(value);
            ArgumentOutOfRangeException.ThrowIfGreaterThan(value, int.MaxValue);
            _position = (int)value;
        }
    }

    public override int ReadByte()
    {
        ThrowClosed();
        ReadOnlySpan<byte> span = _buffer.Span;
        int pos = _position;
        if ((uint)pos < (uint)span.Length) { _position++; return span[pos]; }
        return -1;
    }

    public override int Read(byte[] buffer, int offset, int count)
    {
        ValidateBufferArguments(buffer, offset, count);
        return Read(new Span<byte>(buffer, offset, count));
    }

    public override int Read(Span<byte> buffer)
    {
        ThrowClosed();
        int remaining = _buffer.Length - _position;
        if (remaining <= 0 || buffer.Length == 0) return 0;
        int n = Math.Min(remaining, buffer.Length);
        _buffer.Span.Slice(_position, n).CopyTo(buffer);
        _position += n;
        return n;
    }

    public override void CopyTo(Stream destination, int bufferSize)
    {
        ValidateCopyToArguments(destination, bufferSize);
        ThrowClosed();
        if (_buffer.Length > _position)
        {
            destination.Write(_buffer.Span.Slice(_position));
            _position = _buffer.Length;
        }
    }

    public override long Seek(long offset, SeekOrigin origin)
    {
        ThrowClosed();
        long newPos = origin switch
        {
            SeekOrigin.Begin => offset,
            SeekOrigin.Current => _position + offset,
            SeekOrigin.End => _buffer.Length + offset,
            _ => throw new ArgumentException("Invalid seek origin")
        };
        if (newPos < 0) throw new IOException("Seek before begin");
        _position = (int)newPos;
        return newPos;
    }

    public override void Write(byte[] buffer, int offset, int count) => throw new NotSupportedException();
    public override void Write(ReadOnlySpan<byte> buffer) => throw new NotSupportedException();
    public override void WriteByte(byte value) => throw new NotSupportedException();
    public override void SetLength(long value) => throw new NotSupportedException();
    public override void Flush() { }

    public override byte[] GetBuffer() => throw new UnauthorizedAccessException();
    public override bool TryGetBuffer(out ArraySegment<byte> buffer) { buffer = default; return false; }
    public override byte[] ToArray()
    {
        ThrowClosed();
        if (_buffer.Length == 0) return Array.Empty<byte>();
        byte[] copy = GC.AllocateUninitializedArray<byte>(_buffer.Length);
        _buffer.Span.CopyTo(copy);
        return copy;
    }

    public override void WriteTo(Stream stream) { ArgumentNullException.ThrowIfNull(stream); ThrowClosed(); if (_buffer.Length > 0) stream.Write(_buffer.Span); }

    protected override void Dispose(bool disposing) { _isOpen = false; _buffer = default; base.Dispose(disposing); }
    private void ThrowClosed() => ObjectDisposedException.ThrowIf(!_isOpen, this);
}

// ═══════════════════════════════════════════════════════════════════════════════
// Variant B: ReadOnlyMemoryStream : Stream (alternative — identical method bodies)
// ═══════════════════════════════════════════════════════════════════════════════

public class ReadOnlyMemoryStreamS : Stream
{
    private ReadOnlyMemory<byte> _buffer;
    private int _position;
    private bool _isOpen;

    public ReadOnlyMemoryStreamS(ReadOnlyMemory<byte> source)
    {
        _buffer = source;
        _isOpen = true;
    }

    public override bool CanRead => _isOpen;
    public override bool CanSeek => _isOpen;
    public override bool CanWrite => false;
    public override long Length { get { ThrowClosed(); return _buffer.Length; } }

    public override long Position
    {
        get { ThrowClosed(); return _position; }
        set
        {
            ThrowClosed();
            ArgumentOutOfRangeException.ThrowIfNegative(value);
            ArgumentOutOfRangeException.ThrowIfGreaterThan(value, int.MaxValue);
            _position = (int)value;
        }
    }

    public override int ReadByte()
    {
        ThrowClosed();
        ReadOnlySpan<byte> span = _buffer.Span;
        int pos = _position;
        if ((uint)pos < (uint)span.Length) { _position++; return span[pos]; }
        return -1;
    }

    public override int Read(byte[] buffer, int offset, int count)
    {
        ValidateBufferArguments(buffer, offset, count);
        return Read(new Span<byte>(buffer, offset, count));
    }

    public override int Read(Span<byte> buffer)
    {
        ThrowClosed();
        int remaining = _buffer.Length - _position;
        if (remaining <= 0 || buffer.Length == 0) return 0;
        int n = Math.Min(remaining, buffer.Length);
        _buffer.Span.Slice(_position, n).CopyTo(buffer);
        _position += n;
        return n;
    }

    public override void CopyTo(Stream destination, int bufferSize)
    {
        ValidateCopyToArguments(destination, bufferSize);
        ThrowClosed();
        if (_buffer.Length > _position)
        {
            destination.Write(_buffer.Span.Slice(_position));
            _position = _buffer.Length;
        }
    }

    public override long Seek(long offset, SeekOrigin origin)
    {
        ThrowClosed();
        long newPos = origin switch
        {
            SeekOrigin.Begin => offset,
            SeekOrigin.Current => _position + offset,
            SeekOrigin.End => _buffer.Length + offset,
            _ => throw new ArgumentException("Invalid seek origin")
        };
        if (newPos < 0) throw new IOException("Seek before begin");
        _position = (int)newPos;
        return newPos;
    }

    public override void Write(byte[] buffer, int offset, int count) => throw new NotSupportedException();
    public override void Write(ReadOnlySpan<byte> buffer) => throw new NotSupportedException();
    public override void WriteByte(byte value) => throw new NotSupportedException();
    public override void SetLength(long value) => throw new NotSupportedException();
    public override void Flush() { }

    protected override void Dispose(bool disposing) { _isOpen = false; _buffer = default; base.Dispose(disposing); }
    private void ThrowClosed() => ObjectDisposedException.ThrowIf(!_isOpen, this);
}

// ═══════════════════════════════════════════════════════════════════════════════
// Variant A: WritableMemoryStream : MemoryStream
// ═══════════════════════════════════════════════════════════════════════════════

public class WritableMemoryStreamMS : MemoryStream
{
    private Memory<byte> _buffer;
    private int _position;
    private int _length;
    private bool _isOpen;

    public WritableMemoryStreamMS(Memory<byte> buffer) : base()
    {
        _buffer = buffer;
        _length = 0;
        _isOpen = true;
    }

    public override bool CanRead => _isOpen;
    public override bool CanSeek => _isOpen;
    public override bool CanWrite => _isOpen;
    public override int Capacity { get => _buffer.Length; set => throw new NotSupportedException(); }
    public override long Length { get { ThrowClosed(); return _length; } }

    public override long Position
    {
        get { ThrowClosed(); return _position; }
        set
        {
            ThrowClosed();
            ArgumentOutOfRangeException.ThrowIfNegative(value);
            ArgumentOutOfRangeException.ThrowIfGreaterThan(value, int.MaxValue);
            _position = (int)value;
        }
    }

    public override int ReadByte()
    {
        ThrowClosed();
        ReadOnlySpan<byte> span = _buffer.Span;
        int pos = _position;
        if ((uint)pos < (uint)_length) { _position++; return span[pos]; }
        return -1;
    }

    public override int Read(byte[] buffer, int offset, int count)
    {
        ValidateBufferArguments(buffer, offset, count);
        return Read(new Span<byte>(buffer, offset, count));
    }

    public override int Read(Span<byte> buffer)
    {
        ThrowClosed();
        int remaining = _length - _position;
        if (remaining <= 0 || buffer.Length == 0) return 0;
        int n = Math.Min(remaining, buffer.Length);
        ((ReadOnlyMemory<byte>)_buffer).Span.Slice(_position, n).CopyTo(buffer);
        _position += n;
        return n;
    }

    public override void WriteByte(byte value)
    {
        ThrowClosed();
        if (_position >= _buffer.Length) throw new NotSupportedException();
        _buffer.Span[_position++] = value;
        if (_position > _length) _length = _position;
    }

    public override void Write(byte[] buffer, int offset, int count)
    {
        ValidateBufferArguments(buffer, offset, count);
        Write(new ReadOnlySpan<byte>(buffer, offset, count));
    }

    public override void Write(ReadOnlySpan<byte> buffer)
    {
        ThrowClosed();
        if (buffer.Length == 0) return;
        if (_position > _buffer.Length - buffer.Length) throw new NotSupportedException();
        buffer.CopyTo(_buffer.Span.Slice(_position));
        _position += buffer.Length;
        if (_position > _length) _length = _position;
    }

    public override void CopyTo(Stream destination, int bufferSize)
    {
        ValidateCopyToArguments(destination, bufferSize);
        ThrowClosed();
        if (_length > _position)
        {
            destination.Write(((ReadOnlyMemory<byte>)_buffer).Span.Slice(_position, _length - _position));
            _position = _length;
        }
    }

    public override long Seek(long offset, SeekOrigin origin)
    {
        ThrowClosed();
        long newPos = origin switch
        {
            SeekOrigin.Begin => offset,
            SeekOrigin.Current => _position + offset,
            SeekOrigin.End => _length + offset,
            _ => throw new ArgumentException("Invalid seek origin")
        };
        if (newPos < 0) throw new IOException("Seek before begin");
        _position = (int)newPos;
        return newPos;
    }

    public override void SetLength(long value) => throw new NotSupportedException();
    public override void Flush() { }

    public override byte[] GetBuffer() => throw new UnauthorizedAccessException();
    public override bool TryGetBuffer(out ArraySegment<byte> buffer) { buffer = default; return false; }
    public override byte[] ToArray()
    {
        ThrowClosed();
        if (_length == 0) return Array.Empty<byte>();
        byte[] copy = GC.AllocateUninitializedArray<byte>(_length);
        ((ReadOnlyMemory<byte>)_buffer).Span.Slice(0, _length).CopyTo(copy);
        return copy;
    }

    public override void WriteTo(Stream stream) { ArgumentNullException.ThrowIfNull(stream); ThrowClosed(); if (_length > 0) stream.Write(((ReadOnlyMemory<byte>)_buffer).Span.Slice(0, _length)); }

    protected override void Dispose(bool disposing) { _isOpen = false; _buffer = default; base.Dispose(disposing); }
    private void ThrowClosed() => ObjectDisposedException.ThrowIf(!_isOpen, this);
}

// ═══════════════════════════════════════════════════════════════════════════════
// Variant B: WritableMemoryStream : Stream
// ═══════════════════════════════════════════════════════════════════════════════

public class WritableMemoryStreamS : Stream
{
    private Memory<byte> _buffer;
    private int _position;
    private int _length;
    private bool _isOpen;

    public WritableMemoryStreamS(Memory<byte> buffer)
    {
        _buffer = buffer;
        _length = 0;
        _isOpen = true;
    }

    public override bool CanRead => _isOpen;
    public override bool CanSeek => _isOpen;
    public override bool CanWrite => _isOpen;
    public override long Length { get { ThrowClosed(); return _length; } }

    public override long Position
    {
        get { ThrowClosed(); return _position; }
        set
        {
            ThrowClosed();
            ArgumentOutOfRangeException.ThrowIfNegative(value);
            ArgumentOutOfRangeException.ThrowIfGreaterThan(value, int.MaxValue);
            _position = (int)value;
        }
    }

    public override int ReadByte()
    {
        ThrowClosed();
        ReadOnlySpan<byte> span = _buffer.Span;
        int pos = _position;
        if ((uint)pos < (uint)_length) { _position++; return span[pos]; }
        return -1;
    }

    public override int Read(byte[] buffer, int offset, int count)
    {
        ValidateBufferArguments(buffer, offset, count);
        return Read(new Span<byte>(buffer, offset, count));
    }

    public override int Read(Span<byte> buffer)
    {
        ThrowClosed();
        int remaining = _length - _position;
        if (remaining <= 0 || buffer.Length == 0) return 0;
        int n = Math.Min(remaining, buffer.Length);
        ((ReadOnlyMemory<byte>)_buffer).Span.Slice(_position, n).CopyTo(buffer);
        _position += n;
        return n;
    }

    public override void WriteByte(byte value)
    {
        ThrowClosed();
        if (_position >= _buffer.Length) throw new NotSupportedException();
        _buffer.Span[_position++] = value;
        if (_position > _length) _length = _position;
    }

    public override void Write(byte[] buffer, int offset, int count)
    {
        ValidateBufferArguments(buffer, offset, count);
        Write(new ReadOnlySpan<byte>(buffer, offset, count));
    }

    public override void Write(ReadOnlySpan<byte> buffer)
    {
        ThrowClosed();
        if (buffer.Length == 0) return;
        if (_position > _buffer.Length - buffer.Length) throw new NotSupportedException();
        buffer.CopyTo(_buffer.Span.Slice(_position));
        _position += buffer.Length;
        if (_position > _length) _length = _position;
    }

    public override void CopyTo(Stream destination, int bufferSize)
    {
        ValidateCopyToArguments(destination, bufferSize);
        ThrowClosed();
        if (_length > _position)
        {
            destination.Write(((ReadOnlyMemory<byte>)_buffer).Span.Slice(_position, _length - _position));
            _position = _length;
        }
    }

    public override long Seek(long offset, SeekOrigin origin)
    {
        ThrowClosed();
        long newPos = origin switch
        {
            SeekOrigin.Begin => offset,
            SeekOrigin.Current => _position + offset,
            SeekOrigin.End => _length + offset,
            _ => throw new ArgumentException("Invalid seek origin")
        };
        if (newPos < 0) throw new IOException("Seek before begin");
        _position = (int)newPos;
        return newPos;
    }

    public override void SetLength(long value) => throw new NotSupportedException();
    public override void Flush() { }

    protected override void Dispose(bool disposing) { _isOpen = false; _buffer = default; base.Dispose(disposing); }
    private void ThrowClosed() => ObjectDisposedException.ThrowIf(!_isOpen, this);
}

ViveliDuCh · 2026-06-01T22:31:40Z

Note

AI-generated content (Copilot)

Base Class Benchmark: `WritableMemoryStream` — `MemoryStream` vs `Stream`

Companion to the ReadOnlyMemoryStream benchmark above. Per the API review decision, both ReadOnlyMemoryStream and WritableMemoryStream derive from MemoryStream.

This benchmark covers the writable path with identical method bodies, differing only in base class. Categories:

Construction — object size (~85 vs ~41 bytes for writable, extra _length field)
WriteByte — per-byte write hot loop (concrete type)
WriteByte_Polymorphic — per-byte write via Stream reference
WriteSpan — 256-byte chunked writes
ReadByteAfterWrite — fill buffer then read back per-byte
CopyToAfterWrite — fill buffer then CopyTo
BinaryReader — fill buffer then read through BinaryReader

@EgorBot -linux_amd -osx_arm64

using System;
using System.IO;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Configs;
using BenchmarkDotNet.Running;

BenchmarkSwitcher.FromAssembly(typeof(WritableStreamBenchmarks).Assembly).Run(args);

// ═══════════════════════════════════════════════════════════════════════════════
// Benchmark: WritableMemoryStream — MemoryStream base vs Stream base
// ═══════════════════════════════════════════════════════════════════════════════

[MemoryDiagnoser]
[GroupBenchmarksBy(BenchmarkLogicalGroupRule.ByCategory)]
[CategoriesColumn]
public class WritableStreamBenchmarks
{
    private byte[] _data = default!;

    [Params(1024, 65536)]
    public int Size { get; set; }

    [GlobalSetup]
    public void Setup()
    {
        _data = new byte[Size];
        new Random(42).NextBytes(_data);
    }

    // ── Construction ──

    [BenchmarkCategory("Construction"), Benchmark(Baseline = true)]
    public object Construct_MemoryStreamBase() => new WritableMemoryStreamMS(new byte[Size]);

    [BenchmarkCategory("Construction"), Benchmark]
    public object Construct_StreamBase() => new WritableMemoryStreamS(new byte[Size]);

    [BenchmarkCategory("Construction"), Benchmark]
    public object Construct_ByteArrayBaseline() => new MemoryStream(new byte[Size], writable: true);

    // ── WriteByte (most sensitive per-call benchmark) ──

    [BenchmarkCategory("WriteByte"), Benchmark(Baseline = true)]
    public void WriteByte_MemoryStreamBase()
    {
        var s = new WritableMemoryStreamMS(new byte[Size]);
        for (int i = 0; i < Size; i++) s.WriteByte((byte)i);
    }

    [BenchmarkCategory("WriteByte"), Benchmark]
    public void WriteByte_StreamBase()
    {
        var s = new WritableMemoryStreamS(new byte[Size]);
        for (int i = 0; i < Size; i++) s.WriteByte((byte)i);
    }

    [BenchmarkCategory("WriteByte"), Benchmark]
    public void WriteByte_ByteArrayBaseline()
    {
        var s = new MemoryStream(new byte[Size], writable: true);
        for (int i = 0; i < Size; i++) s.WriteByte((byte)i);
    }

    // ── WriteByte via Stream reference (polymorphic dispatch) ──

    [BenchmarkCategory("WriteByte_Polymorphic"), Benchmark(Baseline = true)]
    public void WriteBytePoly_MemoryStreamBase()
    {
        Stream s = new WritableMemoryStreamMS(new byte[Size]);
        for (int i = 0; i < Size; i++) s.WriteByte((byte)i);
    }

    [BenchmarkCategory("WriteByte_Polymorphic"), Benchmark]
    public void WriteBytePoly_StreamBase()
    {
        Stream s = new WritableMemoryStreamS(new byte[Size]);
        for (int i = 0; i < Size; i++) s.WriteByte((byte)i);
    }

    // ── WriteSpan (chunked write, 256-byte chunks) ──

    [BenchmarkCategory("WriteSpan"), Benchmark(Baseline = true)]
    public void WriteSpan_MemoryStreamBase()
    {
        var s = new WritableMemoryStreamMS(new byte[Size]);
        ReadOnlySpan<byte> chunk = _data.AsSpan(0, Math.Min(256, Size));
        for (int i = 0; i < Size / Math.Max(chunk.Length, 1); i++) s.Write(chunk);
    }

    [BenchmarkCategory("WriteSpan"), Benchmark]
    public void WriteSpan_StreamBase()
    {
        var s = new WritableMemoryStreamS(new byte[Size]);
        ReadOnlySpan<byte> chunk = _data.AsSpan(0, Math.Min(256, Size));
        for (int i = 0; i < Size / Math.Max(chunk.Length, 1); i++) s.Write(chunk);
    }

    [BenchmarkCategory("WriteSpan"), Benchmark]
    public void WriteSpan_ByteArrayBaseline()
    {
        var s = new MemoryStream(new byte[Size], writable: true);
        ReadOnlySpan<byte> chunk = _data.AsSpan(0, Math.Min(256, Size));
        for (int i = 0; i < Size / Math.Max(chunk.Length, 1); i++) s.Write(chunk);
    }

    // ── ReadByte after write (fill then read back) ──

    [BenchmarkCategory("ReadByteAfterWrite"), Benchmark(Baseline = true)]
    public int ReadByteAfterWrite_MemoryStreamBase()
    {
        var s = new WritableMemoryStreamMS(new byte[Size]);
        s.Write(_data);
        s.Position = 0;
        int count = 0;
        while (s.ReadByte() != -1) count++;
        return count;
    }

    [BenchmarkCategory("ReadByteAfterWrite"), Benchmark]
    public int ReadByteAfterWrite_StreamBase()
    {
        var s = new WritableMemoryStreamS(new byte[Size]);
        s.Write(_data);
        s.Position = 0;
        int count = 0;
        while (s.ReadByte() != -1) count++;
        return count;
    }

    [BenchmarkCategory("ReadByteAfterWrite"), Benchmark]
    public int ReadByteAfterWrite_ByteArrayBaseline()
    {
        var s = new MemoryStream(new byte[Size], writable: true);
        s.Write(_data);
        s.Position = 0;
        int count = 0;
        while (s.ReadByte() != -1) count++;
        return count;
    }

    // ── CopyTo after write ──

    [BenchmarkCategory("CopyToAfterWrite"), Benchmark(Baseline = true)]
    public void CopyToAfterWrite_MemoryStreamBase()
    {
        var s = new WritableMemoryStreamMS(new byte[Size]);
        s.Write(_data);
        s.Position = 0;
        s.CopyTo(Stream.Null);
    }

    [BenchmarkCategory("CopyToAfterWrite"), Benchmark]
    public void CopyToAfterWrite_StreamBase()
    {
        var s = new WritableMemoryStreamS(new byte[Size]);
        s.Write(_data);
        s.Position = 0;
        s.CopyTo(Stream.Null);
    }

    [BenchmarkCategory("CopyToAfterWrite"), Benchmark]
    public void CopyToAfterWrite_ByteArrayBaseline()
    {
        var s = new MemoryStream(new byte[Size], writable: true);
        s.Write(_data);
        s.Position = 0;
        s.CopyTo(Stream.Null);
    }

    // ── BinaryReader after write ──

    [BenchmarkCategory("BinaryReader"), Benchmark(Baseline = true)]
    public int BinaryReader_MemoryStreamBase()
    {
        var s = new WritableMemoryStreamMS(new byte[Size]);
        s.Write(_data);
        s.Position = 0;
        using var br = new BinaryReader(s);
        int count = 0;
        for (int i = 0; i < Size; i++) { br.ReadByte(); count++; }
        return count;
    }

    [BenchmarkCategory("BinaryReader"), Benchmark]
    public int BinaryReader_StreamBase()
    {
        var s = new WritableMemoryStreamS(new byte[Size]);
        s.Write(_data);
        s.Position = 0;
        using var br = new BinaryReader(s);
        int count = 0;
        for (int i = 0; i < Size; i++) { br.ReadByte(); count++; }
        return count;
    }

    [BenchmarkCategory("BinaryReader"), Benchmark]
    public int BinaryReader_ByteArrayBaseline()
    {
        var s = new MemoryStream(new byte[Size], writable: true);
        s.Write(_data);
        s.Position = 0;
        using var br = new BinaryReader(s);
        int count = 0;
        for (int i = 0; i < Size; i++) { br.ReadByte(); count++; }
        return count;
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// Variant A: WritableMemoryStream : MemoryStream (current API review decision)
// Source: PR #126669 — sealed subclass, all virtuals overridden, independent state
// ═══════════════════════════════════════════════════════════════════════════════

public class WritableMemoryStreamMS : MemoryStream
{
    private Memory<byte> _buffer;
    private int _position;
    private int _length;
    private bool _isOpen;

    public WritableMemoryStreamMS(Memory<byte> buffer) : base()
    {
        _buffer = buffer;
        _length = 0;
        _isOpen = true;
    }

    public override bool CanRead => _isOpen;
    public override bool CanSeek => _isOpen;
    public override bool CanWrite => _isOpen;
    public override int Capacity { get => _buffer.Length; set => throw new NotSupportedException(); }
    public override long Length { get { ThrowClosed(); return _length; } }

    public override long Position
    {
        get { ThrowClosed(); return _position; }
        set
        {
            ThrowClosed();
            ArgumentOutOfRangeException.ThrowIfNegative(value);
            ArgumentOutOfRangeException.ThrowIfGreaterThan(value, int.MaxValue);
            _position = (int)value;
        }
    }

    public override int ReadByte()
    {
        ThrowClosed();
        ReadOnlySpan<byte> span = _buffer.Span;
        int pos = _position;
        if ((uint)pos < (uint)_length) { _position++; return span[pos]; }
        return -1;
    }

    public override int Read(byte[] buffer, int offset, int count)
    {
        ValidateBufferArguments(buffer, offset, count);
        return Read(new Span<byte>(buffer, offset, count));
    }

    public override int Read(Span<byte> buffer)
    {
        ThrowClosed();
        int remaining = _length - _position;
        if (remaining <= 0 || buffer.Length == 0) return 0;
        int n = Math.Min(remaining, buffer.Length);
        ((ReadOnlyMemory<byte>)_buffer).Span.Slice(_position, n).CopyTo(buffer);
        _position += n;
        return n;
    }

    public override void WriteByte(byte value)
    {
        ThrowClosed();
        if (_position >= _buffer.Length) throw new NotSupportedException();
        _buffer.Span[_position++] = value;
        if (_position > _length) _length = _position;
    }

    public override void Write(byte[] buffer, int offset, int count)
    {
        ValidateBufferArguments(buffer, offset, count);
        Write(new ReadOnlySpan<byte>(buffer, offset, count));
    }

    public override void Write(ReadOnlySpan<byte> buffer)
    {
        ThrowClosed();
        if (buffer.Length == 0) return;
        if (_position > _buffer.Length - buffer.Length) throw new NotSupportedException();
        buffer.CopyTo(_buffer.Span.Slice(_position));
        _position += buffer.Length;
        if (_position > _length) _length = _position;
    }

    public override void CopyTo(Stream destination, int bufferSize)
    {
        ValidateCopyToArguments(destination, bufferSize);
        ThrowClosed();
        if (_length > _position)
        {
            destination.Write(((ReadOnlyMemory<byte>)_buffer).Span.Slice(_position, _length - _position));
            _position = _length;
        }
    }

    public override long Seek(long offset, SeekOrigin origin)
    {
        ThrowClosed();
        long newPos = origin switch
        {
            SeekOrigin.Begin => offset,
            SeekOrigin.Current => _position + offset,
            SeekOrigin.End => _length + offset,
            _ => throw new ArgumentException("Invalid seek origin")
        };
        if (newPos < 0) throw new IOException("Seek before begin");
        _position = (int)newPos;
        return newPos;
    }

    public override void SetLength(long value) => throw new NotSupportedException();
    public override void Flush() { }

    public override byte[] GetBuffer() => throw new UnauthorizedAccessException();
    public override bool TryGetBuffer(out ArraySegment<byte> buffer) { buffer = default; return false; }
    public override byte[] ToArray()
    {
        ThrowClosed();
        if (_length == 0) return Array.Empty<byte>();
        byte[] copy = GC.AllocateUninitializedArray<byte>(_length);
        ((ReadOnlyMemory<byte>)_buffer).Span.Slice(0, _length).CopyTo(copy);
        return copy;
    }

    public override void WriteTo(Stream stream)
    {
        ArgumentNullException.ThrowIfNull(stream);
        ThrowClosed();
        if (_length > 0) stream.Write(((ReadOnlyMemory<byte>)_buffer).Span.Slice(0, _length));
    }

    protected override void Dispose(bool disposing) { _isOpen = false; _buffer = default; base.Dispose(disposing); }
    private void ThrowClosed() => ObjectDisposedException.ThrowIf(!_isOpen, this);
}

// ═══════════════════════════════════════════════════════════════════════════════
// Variant B: WritableMemoryStream : Stream (alternative — identical method bodies)
// ═══════════════════════════════════════════════════════════════════════════════

public class WritableMemoryStreamS : Stream
{
    private Memory<byte> _buffer;
    private int _position;
    private int _length;
    private bool _isOpen;

    public WritableMemoryStreamS(Memory<byte> buffer)
    {
        _buffer = buffer;
        _length = 0;
        _isOpen = true;
    }

    public override bool CanRead => _isOpen;
    public override bool CanSeek => _isOpen;
    public override bool CanWrite => _isOpen;
    public override long Length { get { ThrowClosed(); return _length; } }

    public override long Position
    {
        get { ThrowClosed(); return _position; }
        set
        {
            ThrowClosed();
            ArgumentOutOfRangeException.ThrowIfNegative(value);
            ArgumentOutOfRangeException.ThrowIfGreaterThan(value, int.MaxValue);
            _position = (int)value;
        }
    }

    public override int ReadByte()
    {
        ThrowClosed();
        ReadOnlySpan<byte> span = _buffer.Span;
        int pos = _position;
        if ((uint)pos < (uint)_length) { _position++; return span[pos]; }
        return -1;
    }

    public override int Read(byte[] buffer, int offset, int count)
    {
        ValidateBufferArguments(buffer, offset, count);
        return Read(new Span<byte>(buffer, offset, count));
    }

    public override int Read(Span<byte> buffer)
    {
        ThrowClosed();
        int remaining = _length - _position;
        if (remaining <= 0 || buffer.Length == 0) return 0;
        int n = Math.Min(remaining, buffer.Length);
        ((ReadOnlyMemory<byte>)_buffer).Span.Slice(_position, n).CopyTo(buffer);
        _position += n;
        return n;
    }

    public override void WriteByte(byte value)
    {
        ThrowClosed();
        if (_position >= _buffer.Length) throw new NotSupportedException();
        _buffer.Span[_position++] = value;
        if (_position > _length) _length = _position;
    }

    public override void Write(byte[] buffer, int offset, int count)
    {
        ValidateBufferArguments(buffer, offset, count);
        Write(new ReadOnlySpan<byte>(buffer, offset, count));
    }

    public override void Write(ReadOnlySpan<byte> buffer)
    {
        ThrowClosed();
        if (buffer.Length == 0) return;
        if (_position > _buffer.Length - buffer.Length) throw new NotSupportedException();
        buffer.CopyTo(_buffer.Span.Slice(_position));
        _position += buffer.Length;
        if (_position > _length) _length = _position;
    }

    public override void CopyTo(Stream destination, int bufferSize)
    {
        ValidateCopyToArguments(destination, bufferSize);
        ThrowClosed();
        if (_length > _position)
        {
            destination.Write(((ReadOnlyMemory<byte>)_buffer).Span.Slice(_position, _length - _position));
            _position = _length;
        }
    }

    public override long Seek(long offset, SeekOrigin origin)
    {
        ThrowClosed();
        long newPos = origin switch
        {
            SeekOrigin.Begin => offset,
            SeekOrigin.Current => _position + offset,
            SeekOrigin.End => _length + offset,
            _ => throw new ArgumentException("Invalid seek origin")
        };
        if (newPos < 0) throw new IOException("Seek before begin");
        _position = (int)newPos;
        return newPos;
    }

    public override void SetLength(long value) => throw new NotSupportedException();
    public override void Flush() { }

    protected override void Dispose(bool disposing) { _isOpen = false; _buffer = default; base.Dispose(disposing); }
    private void ThrowClosed() => ObjectDisposedException.ThrowIf(!_isOpen, this);
}

… structure

Copilot

Pull request overview

Copilot reviewed 25 out of 25 changed files in this pull request and generated 5 comments.

…s, and conformance coverage

Copilot

Pull request overview

Copilot reviewed 25 out of 25 changed files in this pull request and generated 5 comments.

jozkee · 2026-06-17T17:02:04Z

+    public class ReadOnlySequenceStreamTests
+    {
+        [Fact]
+        public void ReadZeroBytesReturnsZero()


This seems like a duplicate of

runtime/src/libraries/Common/tests/StreamConformanceTests/System/IO/StreamConformanceTests.cs

Lines 767 to 780 in 8e4a441

public virtual async Task Read_NonEmptyStream_Nop_Success(ReadWriteMode mode)

{

if (SkipOnWasi(mode)) return;

using Stream? stream = await CreateReadOnlyStream(new byte[10]);

if (stream is null)

{

return;

}

Assert.Equal(0, await ReadAsync(mode, stream, Array.Empty<byte>(), 0, 0));

Assert.Equal(0, await ReadAsync(mode, stream, new byte[0], 0, 0));

Assert.Equal(0, await ReadAsync(mode, stream, new byte[1], 0, 0));

Assert.Equal(0, await ReadAsync(mode, stream, new byte[1], 1, 0));

Can you try to ask copilot to cross-reference all your tests, so they are not duplicating the ones from StreamConformanceTests. That's how I found these.

jozkee · 2026-06-17T17:02:08Z

+        }
+
+        [Fact]
+        public void SeekingBeyondEmptyBufferIsAllowed()


We should maybe instead update Seek_PastEnd_ReadReturns0 to assert Position is updated when seeking past stream.

runtime/src/libraries/Common/tests/StreamConformanceTests/System/IO/StreamConformanceTests.cs

Lines 1341 to 1363 in 8e4a441

public virtual async Task Seek_PastEnd_ReadReturns0(SeekMode mode)

{

if (!CanSeek)

{

return;

}

const int Length = 512;

byte[] expected = GetRandomBytes(Length);

using Stream? stream = await CreateReadOnlyStream(expected);

if (stream is null)

{

return;

}

long pos = stream.Length + 10;

Assert.Equal(pos, Seek(mode, stream, pos));

Assert.Equal(0, stream.Read(new byte[1], 0, 1));

Assert.Equal(-1, stream.ReadByte());

}

Decided to keep the Position assertion local rather than push into Seek_PastEnd_ReadReturns0 — the conformance test already asserts Seek returns pos, which by the Stream.Seek contract equals Position, so adding Assert.Equal(pos, stream.Position) to the shared test would be redundant and risks failing any stream whose Position impl quietly diverges from its Seek return value (e.g. buffered streams when seeking past end). The narrow assertion in this PR's tests is enough to guard the wrapper's behavior without changing the contract surface for every other stream in the repo.

jozkee · 2026-06-17T17:04:46Z

+            Task<int> task1 = stream.ReadAsync(buffer1, 0, 5);
+            Task<int> task2 = stream.ReadAsync(buffer2, 0, 5);
+            Task<int> task3 = stream.ReadAsync(buffer3, 0, 5);
+
+            await task1;
+            await task2;
+            await task3;
+
+            Assert.Same(task1, task2);
+            Assert.Same(task2, task3);
+


You may want to reconsider this one, I don't see the Task caching optimization built into ReadOnlySequenceStream.

jozkee · 2026-06-17T17:05:15Z

+        }
+
+        [Fact]
+        public async Task ReadAsyncArrayBackedMemoryUsesFastPath()


This isn't testing any fast path I believe and there's nothing special about it. I suggest removing it.

jozkee · 2026-06-17T21:38:05Z

+        {
+            return 0;
+        }
+


Have you considered adding a single-shot Encoding.GetBytes fast path? It is ~34% faster than using Encoder.Convert and avoids some allocations: https://gist.github.com/jozkee/ec72a16575edac7fcbde864cde61cd76.

Results:

Method Length Mean Error StdDev Ratio Gen0 Allocated Alloc Ratio

Baseline 16 40.10 ns 6.150 ns 0.337 ns 1.00 0.0100 168 B 1.00

OneShot 16 26.60 ns 2.302 ns 0.126 ns 0.66 0.0076 128 B 0.76

Baseline 1024 57.02 ns 3.955 ns 0.217 ns 1.00 0.0100 168 B 1.00

OneShot 1024 42.24 ns 8.008 ns 0.439 ns 0.74 0.0076 128 B 0.76

jozkee · 2026-06-17T21:43:50Z

+            // cannot hold a single complete encoded character.
+            if (buffer.Length < _encoding.GetMaxByteCount(1))
+            {
+                _pendingBytes ??= new byte[_encoding.GetMaxByteCount(2)];


This could benefit a bit from GC.AllocateUninitializedArray, as done in

runtime/src/libraries/System.Private.CoreLib/src/System/Text/TranscodingStream.cs

Line 201 in 067b864

_readBuffer = GC.AllocateUninitializedArray<byte>(_thisEncoding.GetMaxByteCount(_readCharBufferMaxSize));

jozkee · 2026-06-17T21:44:20Z

+
+        _text = text.AsMemory();
+        _encoding = encoding;
+        _encoder = encoding.GetEncoder();


If we do #126669 (comment), we should lazy-init this.

jozkee · 2026-06-17T21:45:04Z

+        _disposed = true;
+        base.Dispose(disposing);
+    }
+}


Should CopyTo[Async] be overridden?

…ridging, Seek hardening, and test dedup

Copilot

Pull request overview

Copilot reviewed 24 out of 25 changed files in this pull request and generated 8 comments.

Comments suppressed due to low confidence (1)

src/libraries/System.Runtime/tests/System.IO.Tests/WritableMemoryStream/WritableMemoryStreamTests.cs:118

The new WritableMemoryStream type documents that GetBuffer throws and TryGetBuffer returns false, but the tests here don't assert that behavior. Adding a small test would lock in the intended contract (and distinguish it from MemoryStream's default behavior).

            Assert.Equal(data, manager.GetSpan().ToArray());
            Assert.Equal(data.Length, stream.Position);
        }
    }
}

+            if (_charPosition == 0 && _pendingCount == 0 &&
+                buffer.Length >= _encoding.GetMaxByteCount(_text.Length))
+            {
+                int written = _encoding.GetBytes(_text.Span, buffer);
+                _charPosition = _text.Length;
+                _encoderFlushed = true;
+                return written;
+            }


+            // Size the rented buffer to the remaining encoded payload (capped by bufferSize).
+            // The base Stream.CopyTo falls back to an 80 KB buffer because our Length throws;
+            // sizing here avoids that waste and lets the single-shot Read fast path consume
+            // the entire input in one call when the rented buffer is large enough.
+            int maxBytes = _encoding.GetMaxByteCount(_text.Length - _charPosition);
+            int rentSize = Math.Max(1, Math.Min(maxBytes, bufferSize));
+            byte[] buffer = ArrayPool<byte>.Shared.Rent(rentSize);


+            int maxBytes = _encoding.GetMaxByteCount(_text.Length - _charPosition);
+            int rentSize = Math.Max(1, Math.Min(maxBytes, bufferSize));
+            return CopyToAsyncCore(destination, rentSize, cancellationToken);


+            long newPosition = origin switch
+            {
+                SeekOrigin.Begin => offset,
+                SeekOrigin.Current => _position + offset,
+                SeekOrigin.End => _buffer.Length + offset,
+                _ => throw new ArgumentOutOfRangeException(nameof(origin))
+            };


+            long newPosition = origin switch
+            {
+                SeekOrigin.Begin => offset,
+                SeekOrigin.Current => _position + offset,
+                SeekOrigin.End => _length + offset,
+                _ => throw new ArgumentOutOfRangeException(nameof(origin))
+            };


+            long absolutePosition = origin switch
+            {
+                SeekOrigin.Begin => offset,
+                SeekOrigin.Current => _absolutePosition + offset,
+                SeekOrigin.End => _sequence.Length + offset,
+                _ => throw new ArgumentOutOfRangeException(nameof(origin))
+            };


+
+    public sealed class ReadOnlySequenceStream : Stream
+    {


+        }
+    }
+}


…ds, GetBuffer contract tests, ReadOnlySequenceStream XML doc

ViveliDuCh and others added 3 commits April 8, 2026 13:17

First API proposal implementation

1f1bfe1

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

API replacements in production code

f7a06f0

Implementation update based on latest API Review final consensus

bd5cf98

ViveliDuCh requested review from Copilot and jozkee April 8, 2026 22:31

github-actions Bot added the area-System.Memory label Apr 8, 2026

dotnet-policy-service Bot assigned ViveliDuCh Apr 8, 2026

ViveliDuCh added the area-System.IO label Apr 8, 2026

Copilot started reviewing on behalf of ViveliDuCh April 8, 2026 22:32 View session

Copilot AI reviewed Apr 8, 2026

View reviewed changes

stephentoub reviewed Apr 9, 2026

View reviewed changes

Copilot AI review requested due to automatic review settings April 9, 2026 08:01

ViveliDuCh force-pushed the stream-wrappers-api branch from 27761ff to b43698b Compare April 9, 2026 08:01

Copilot started reviewing on behalf of ViveliDuCh April 9, 2026 08:03 View session

ViveliDuCh force-pushed the stream-wrappers-api branch from b43698b to 95a2989 Compare April 9, 2026 08:06

Copilot AI reviewed Apr 9, 2026

View reviewed changes

ViveliDuCh force-pushed the stream-wrappers-api branch from 95a2989 to 5e3f98c Compare April 9, 2026 19:59

Copilot AI mentioned this pull request Apr 11, 2026

Fix WasmTestOnChrome: exclude browser/wasi from gen-debug-dump-docs.py helix post-command #126789

Merged

1 task

Address PR feedback. MemoryStream base change. Spillover buffer for C…

fec7a59

…onvert edge case. Flush strategy update.

Copilot AI review requested due to automatic review settings April 13, 2026 19:23

ViveliDuCh force-pushed the stream-wrappers-api branch from 5e3f98c to fec7a59 Compare April 13, 2026 19:23

Copilot started reviewing on behalf of ViveliDuCh April 13, 2026 19:24 View session

Copilot AI reviewed Apr 13, 2026

View reviewed changes

Comment thread src/libraries/System.Private.CoreLib/src/System/IO/ReadOnlyMemoryStream.cs Outdated

Comment thread src/libraries/System.Private.CoreLib/src/System/IO/StringStream.cs Outdated

Comment thread src/libraries/System.Private.CoreLib/src/System/IO/WritableMemoryStream.cs Outdated

tarekgh reviewed Apr 13, 2026

View reviewed changes

Comment thread src/libraries/System.Private.CoreLib/src/System/IO/WritableMemoryStream.cs Outdated

Copilot started reviewing on behalf of ViveliDuCh May 29, 2026 15:29 View session

Copilot AI reviewed May 29, 2026

View reviewed changes

Comment thread src/libraries/System.Private.CoreLib/src/System/IO/ReadOnlyMemoryStream.cs Outdated

Comment thread src/libraries/System.Private.CoreLib/src/System/IO/WritableMemoryStream.cs Outdated

Comment thread src/libraries/System.Memory/src/System/Buffers/ReadOnlySequenceStream.cs

This was referenced May 30, 2026

XHarness package install failure on iOS due to devicectl NSPOSIXErrorDomain error 49 #123796

Open

DnsGetHostAddresses_LocalhostWithTrailingDot_ReturnsLoopback - SocketException : Name or service not known #128759

Open

adamsitnik reviewed Jun 1, 2026

View reviewed changes

EgorBot mentioned this pull request Jun 1, 2026

Benchmarks for dotnet/runtime#126669 (for @ViveliDuCh) EgorBot/Benchmarks#229

Open

EgorBot mentioned this pull request Jun 1, 2026

Benchmarks for dotnet/runtime#126669 (for @ViveliDuCh) EgorBot/Benchmarks#230

Open

jozkee reviewed Jun 2, 2026

View reviewed changes

Comment thread src/libraries/System.Runtime/tests/System.IO.Tests/StringStream/StringStreamTests_Memory.cs Outdated

ViveliDuCh and others added 3 commits June 15, 2026 10:17

Merge branch 'dotnet:main' into stream-wrappers-api

430515a

Address PR feedback: remove redundant code, improve test coverage and…

0946bfc

… structure

Merge remote-tracking branch

d5103d1

Copilot AI review requested due to automatic review settings June 16, 2026 20:55

Copilot started reviewing on behalf of ViveliDuCh June 16, 2026 20:55 View session

Copilot AI reviewed Jun 16, 2026

View reviewed changes

Address PR feedback: gap-zeroing, disposal checks, cancellation guard…

8e4a441

…s, and conformance coverage

Copilot AI review requested due to automatic review settings June 17, 2026 06:30

ViveliDuCh force-pushed the stream-wrappers-api branch from d8e4b7a to 8e4a441 Compare June 17, 2026 06:30

Copilot started reviewing on behalf of ViveliDuCh June 17, 2026 06:30 View session

Copilot AI reviewed Jun 17, 2026

View reviewed changes

jozkee reviewed Jun 17, 2026

View reviewed changes

ViveliDuCh added 2 commits June 18, 2026 01:36

Cache ReadAsync Task<int> in ReadOnly/Writable MemoryStream wrappers

70f9f8b

Address feedback: perf fast paths, CopyTo overrides, sync-exception b…

242dbd5

…ridging, Seek hardening, and test dedup

jozkee requested a review from Copilot June 19, 2026 22:00

Copilot started reviewing on behalf of jozkee June 19, 2026 22:01 View session

Copilot AI reviewed Jun 19, 2026

View reviewed changes

Address review: BCL Seek exception parity, StringStream overflow guar…

af11328

…ds, GetBuffer contract tests, ReadOnlySequenceStream XML doc

	public virtual async Task Read_NonEmptyStream_Nop_Success(ReadWriteMode mode)
	{
	if (SkipOnWasi(mode)) return;

	using Stream? stream = await CreateReadOnlyStream(new byte[10]);
	if (stream is null)
	{
	return;
	}

	Assert.Equal(0, await ReadAsync(mode, stream, Array.Empty<byte>(), 0, 0));
	Assert.Equal(0, await ReadAsync(mode, stream, new byte[0], 0, 0));
	Assert.Equal(0, await ReadAsync(mode, stream, new byte[1], 0, 0));
	Assert.Equal(0, await ReadAsync(mode, stream, new byte[1], 1, 0));

	public virtual async Task Seek_PastEnd_ReadReturns0(SeekMode mode)
	{
	if (!CanSeek)
	{
	return;
	}

	const int Length = 512;

	byte[] expected = GetRandomBytes(Length);
	using Stream? stream = await CreateReadOnlyStream(expected);
	if (stream is null)
	{
	return;
	}

	long pos = stream.Length + 10;
	Assert.Equal(pos, Seek(mode, stream, pos));

	Assert.Equal(0, stream.Read(new byte[1], 0, 1));
	Assert.Equal(-1, stream.ReadByte());
	}

Method	Length	Mean	Error	StdDev	Ratio	Gen0	Allocated	Alloc Ratio
Baseline	16	40.10 ns	6.150 ns	0.337 ns	1.00	0.0100	168 B	1.00
OneShot	16	26.60 ns	2.302 ns	0.126 ns	0.66	0.0076	128 B	0.76

Baseline	1024	57.02 ns	3.955 ns	0.217 ns	1.00	0.0100	168 B	1.00
OneShot	1024	42.24 ns	8.008 ns	0.439 ns	0.74	0.0076	128 B	0.76

Conversation

ViveliDuCh commented Apr 8, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

What's included

Implementation notes

Limitations

Follow-up work

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Uh oh!

Uh oh!

Uh oh!

adamsitnik left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

ViveliDuCh commented Jun 1, 2026

Base Class Benchmark: MemoryStream vs Stream

Uh oh!

ViveliDuCh commented Jun 1, 2026

Base Class Benchmark: WritableMemoryStream — MemoryStream vs Stream

Uh oh!

Uh oh!

ViveliDuCh commented Apr 8, 2026 •

edited

Loading

Base Class Benchmark: `MemoryStream` vs `Stream`

Base Class Benchmark: `WritableMemoryStream` — `MemoryStream` vs `Stream`

jozkee Jun 17, 2026 •

edited

Loading